<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>明天会更好</title>


    <!-- 创作者信息 -->
    <meta name="author" content="超级蒙多">

    <!-- 版权信息 -->
    <meta name="copyright" content="© 2025-11-09 超级蒙多 原创">

    <!-- 页面描述（可选） -->
    <meta name="description" content="这是一个创意页面,代码由chatgpt辅助编辑,最终代码由claudeAi整理并注释">

    <!-- 关键字（可选，用于 SEO） -->
    <meta name="keywords" content="爱心, 创意, 暖心 , 鼓励 , 温暖 ">


    <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/1.10.2/jquery.min.js"></script>
    <style>
        /* ===========================================
           基础样式 - 单个卡片
           =========================================== */
        .单个卡片 {
            width: 200px;
            height: 50px;
            line-height: 50px;
            border-radius: 20px;
            text-align: center;
            color: #dcedff;
            user-select: none;
            cursor: pointer;
            position: absolute;
            transition: all 0.5s ease;
            font-size: 14px;
            font-weight: 500;
            box-shadow: 0 4px 15px rgba(0, 0, 0, 0.1);
        }

        /* 悬停效果：旋转归零 + 放大 + 提升层级 */
        .单个卡片:hover {
            rotate: 0deg !important;
            transform: rotate(0deg) scale(1.15);
            z-index: 10000;
            box-shadow: 0 8px 25px rgba(0, 0, 0, 0.2);
        }

        /* ===========================================
           动画类 - 左右摇摆
           =========================================== */
        .左右摇摆 {
            animation: 左右摇摆动画 1s linear infinite;
            transform-origin: center center;
        }

        @keyframes 左右摇摆动画 {
            0%, 100% {
                transform: rotate(0deg);
            }
            25% {
                transform: rotate(25deg);
            }
            50% {
                transform: rotate(0deg);
            }
            75% {
                transform: rotate(-25deg);
            }
        }

        /* ===========================================
           动画类 - 持续浮动
           =========================================== */
        .持续浮动 {
            animation: 持续浮动动画 3s ease-in-out infinite;
            scale: 1.1;
        }

        @keyframes 持续浮动动画 {
            0%, 100% {
                transform: translateY(0px);
            }
            50% {
                transform: translateY(-20px);
            }
        }

        /* ===========================================
           动画类 - 短暂放大（强调效果）
           =========================================== */
        .短暂放大 {
            animation: 短暂放大动画 1s ease forwards;
        }

        @keyframes 短暂放大动画 {
            0% {
                transform: scale(1);
            }
            50% {
                transform: scale(1.1);
            }
            100% {
                transform: scale(1);
            }
        }

        /* ===========================================
           动态渐变背景
           =========================================== */
        .动态背景 {
            width: 100%;
            height: 100%;
            background: linear-gradient(
                    45deg,
                    #a8e6cf, #dcedff, #ffd6e0,
                    #a8e6cf, #dcedff, #ffd6e0,
                    #a8e6cf
            );
            background-size: 300% 300%;
            animation: 动态背景动画 20s linear infinite;
            will-change: background-position;
        }

        @keyframes 动态背景动画 {
            0% {
                background-position: 0 50%;
            }
            50% {
                background-position: 100% 50%;
            }
            100% {
                background-position: 0 50%;
            }
        }

        /* ===========================================
           爱心特效样式
           =========================================== */
        .爱心 {
            position: absolute;
            transform: translate(-50%, -50%) rotate(45deg);
            pointer-events: none;
            will-change: transform, opacity;
            z-index: 10001;
        }

        .爱心 .爱心主体 {
            width: 100%;
            height: 100%;
            background: red;
            border-radius: 0.25em;
            position: absolute;
            left: 0;
            top: 0;
            transform: translate(-50%, -50%);
        }

        /* 爱心左右两个圆形 */
        .爱心 .爱心主体::before,
        .爱心 .爱心主体::after {
            content: "";
            position: absolute;
            width: 100%;
            height: 100%;
            background: inherit;
            border-radius: 50%;
            top: -50%;
            left: 0;
        }

        .爱心 .爱心主体::after {
            left: -50%;
            top: 0;
        }

        /* 爱心漂浮动画 */
        @keyframes 爱心漂浮动画 {
            0% {
                opacity: 0;
                transform: translate(-50%, 0) rotate(45deg) scale(0.6);
            }
            10% {
                opacity: 1;
                transform: translate(-50%, -10px) rotate(45deg) scale(1.2);
            }
            100% {
                opacity: 0;
                transform: translate(calc(-50% + var(--偏移X, 0px)), var(--上升高度, -200px)) rotate(45deg) scale(0.8);
            }
        }
    </style>
</head>
<body style="overflow: hidden;min-width: 1200px;" class="动态背景">
</body>
<script>
    $(document).ready(function () {
        // ===========================================
        // 全局常量配置
        // ===========================================
        const 配置 = {
            屏幕宽度: window.innerWidth,
            屏幕高度: window.innerHeight,
            卡片宽度: 200,
            卡片高度: 50,
            爱心间隔范围: [500, 3000],
            曲线精度: 0.02,
            飞入延迟间隔: 100,
            飞入动画时长: 5000,
            旋转动画时长: 1000,
            旋转延迟: 6000
        };

        // ===========================================
        // 工具函数集合
        // ===========================================
        const 工具 = {
            /**
             * 生成随机区间值
             * @param {number} 最小值
             * @param {number} 最大值
             * @returns {number}
             */
            随机区间(最小值, 最大值) {
                return 最小值 + Math.random() * (最大值 - 最小值);
            },

            /**
             * 生成随机浅色渐变（蓝/粉/绿色系）
             * @returns {Array<string>} 返回两个颜色的数组
             */
            随机渐变色() {
                const 色系配置 = {
                    蓝: {h: [190, 220], s: [60, 90], l: [70, 85]},
                    粉: {h: [330, 360], s: [60, 90], l: [75, 90]},
                    绿: {h: [90, 140], s: [50, 80], l: [70, 85]}
                };

                // 随机选择两个不同的色系
                const 色系列表 = Object.keys(色系配置);
                const 索引1 = Math.floor(Math.random() * 色系列表.length);
                let 索引2;
                do {
                    索引2 = Math.floor(Math.random() * 色系列表.length);
                } while (索引2 === 索引1);

                const 颜色1 = this.生成HSL颜色(色系配置[色系列表[索引1]]);
                const 颜色2 = this.生成HSL颜色(色系配置[色系列表[索引2]]);

                return [颜色1, 颜色2];
            },

            /**
             * 根据HSL配置生成RGB颜色字符串
             */
            生成HSL颜色({h, s, l}) {
                const H = this.随机区间(h[0], h[1]);
                const S = this.随机区间(s[0], s[1]);
                const L = this.随机区间(l[0], l[1]);
                return this.HSL转RGB(H, S, L);
            },

            /**
             * HSL转RGB颜色
             */
            HSL转RGB(h, s, l) {
                s /= 100;
                l /= 100;
                const k = n => (n + h / 30) % 12;
                const a = s * Math.min(l, 1 - l);
                const f = n => l - a * Math.max(-1, Math.min(k(n) - 3, Math.min(9 - k(n), 1)));
                const r = Math.round(255 * f(0));
                const g = Math.round(255 * f(8));
                const b = Math.round(255 * f(4));
                return `rgb(${r}, ${g}, ${b})`;
            },

            /**
             * 生成爱心形状的坐标点集合
             * @param {number} Y间隔 - 控制Y轴采样密度
             * @param {number} X间隔 - 控制X轴采样密度
             * @returns {Array<Array<number>>} 坐标数组 [[x1,y1], [x2,y2], ...]
             */
            生成爱心坐标(Y间隔 = 2, X间隔 = 1) {
                const 中心X = Math.round(配置.屏幕宽度 / 2.3);
                const 中心Y = Math.round(配置.屏幕高度 / 2.5);
                const 缩放比例 = Math.min(配置.屏幕宽度, 配置.屏幕高度) / 40;
                const 坐标列表 = [];

                // 爱心参数方程
                for (let t = 0; t < Math.PI * 2; t += 0.02) {
                    const x = 16 * Math.pow(Math.sin(t), 3);
                    const y = 13 * Math.cos(t) - 5 * Math.cos(2 * t) - 2 * Math.cos(3 * t) - Math.cos(4 * t);

                    const 屏幕X = Math.round(中心X + x * 缩放比例);
                    const 屏幕Y = Math.round(中心Y - y * 缩放比例);
                    坐标列表.push([屏幕X, 屏幕Y]);
                }

                // 按照间隔进行采样
                const 抽样列表 = [];
                const 步长 = Math.max(1, Math.floor(X间隔 / 2));
                for (let i = 0; i < 坐标列表.length; i += 步长) {
                    if (i % Y间隔 === 0) {
                        抽样列表.push(坐标列表[i]);
                    }
                }

                return 抽样列表;
            },

            /**
             * 生成贝塞尔曲线路径（多段拼接）
             * @param {Array<number>} 起点 - [x, y]
             * @param {Array<number>} 终点 - [x, y]
             * @param {Array<number>} 随机范围 - [最小值, 最大值]
             * @param {Array<number>} 阶数范围 - [最小阶, 最大阶]
             * @returns {Array<Object>} 路径点数组 [{x, y}, ...]
             */
            生成贝塞尔曲线(起点, 终点, 随机范围, 阶数范围) {
                const [x1, y1] = 起点;
                const [x2, y2] = 终点;
                const [随机最小, 随机最大] = 随机范围;
                const [阶最小, 阶最大] = 阶数范围;
                const 路径 = [];

                let 当前点 = {x: x1, y: y1};
                const 段数 = Math.floor(this.随机区间(3, 8));

                for (let 段索引 = 0; 段索引 < 段数; 段索引++) {
                    const 随机阶数 = Math.floor(this.随机区间(阶最小, 阶最大));
                    const 控制点 = [当前点];

                    // 生成中间控制点
                    for (let i = 0; i < 随机阶数 - 1; i++) {
                        控制点.push(this.生成随机点(
                            x1 - 随机最大, y1 - 随机最大,
                            x2 + 随机最大, y2 + 随机最大
                        ));
                    }

                    // 最后一段指向终点，其他段随机
                    if (段索引 === 段数 - 1) {
                        控制点.push({x: x2, y: y2});
                    } else {
                        控制点.push(this.生成随机点(x1, y1, x2, y2));
                    }

                    // 计算这段贝塞尔曲线
                    let 段坐标 = this.计算贝塞尔点(控制点, 配置.曲线精度);
                    段坐标 = this.自适应采样(段坐标, 0.5, 2);

                    // 拼接路径（去除重复点）
                    if (路径.length > 0) 段坐标.shift();
                    路径.push(...段坐标);

                    当前点 = 控制点[控制点.length - 1];
                }

                return 路径;
            },

            /**
             * 生成随机点
             */
            生成随机点(x1, y1, x2, y2) {
                return {
                    x: Math.floor(this.随机区间(x1, x2)),
                    y: Math.floor(this.随机区间(y1, y2))
                };
            },

            /**
             * 计算贝塞尔曲线上的点
             */
            计算贝塞尔点(控制点列表, 精度 = 0.02) {
                const n = 控制点列表.length - 1;
                const 结果 = [];

                for (let t = 0; t <= 1; t += 精度) {
                    let x = 0, y = 0;
                    for (let i = 0; i <= n; i++) {
                        const 组合数 = this.计算组合数(n, i);
                        const 系数 = 组合数 * Math.pow(1 - t, n - i) * Math.pow(t, i);
                        x += 控制点列表[i].x * 系数;
                        y += 控制点列表[i].y * 系数;
                    }
                    结果.push({x: Math.round(x), y: Math.round(y)});
                }

                return 结果;
            },

            /**
             * 计算组合数 C(n, i)
             */
            计算组合数(n, i) {
                let 结果 = 1;
                for (let j = 1; j <= i; j++) {
                    结果 = 结果 * (n - j + 1) / j;
                }
                return 结果;
            },

            /**
             * 根据曲率自适应采样（优化点密度）
             */
            自适应采样(曲线, 最小步长 = 0.5, 最大步长 = 2) {
                if (曲线.length <= 2) return 曲线;

                const 新曲线 = [曲线[0]];
                for (let i = 1; i < 曲线.length - 1; i++) {
                    const p0 = 曲线[i - 1];
                    const p1 = 曲线[i];
                    const p2 = 曲线[i + 1];
                    const 曲率 = this.计算曲率(p0, p1, p2);
                    const 步长 = 最小步长 + (1 - Math.min(曲率 * 5, 1)) * (最大步长 - 最小步长);
                    const 上一点 = 新曲线[新曲线.length - 1];
                    const 距离 = Math.hypot(p1.x - 上一点.x, p1.y - 上一点.y);

                    if (距离 >= 步长) 新曲线.push(p1);
                }
                新曲线.push(曲线[曲线.length - 1]);
                return 新曲线;
            },

            /**
             * 计算三点间的曲率
             */
            计算曲率(p0, p1, p2) {
                const dx1 = p1.x - p0.x;
                const dy1 = p1.y - p0.y;
                const dx2 = p2.x - p1.x;
                const dy2 = p2.y - p1.y;
                const 行列式 = dx1 * dy2 - dy1 * dx2;
                const 模长 = Math.sqrt(dx1 * dx1 + dy1 * dy1) * Math.sqrt(dx2 * dx2 + dy2 * dy2) + 0.0001;
                return Math.abs(行列式) / 模长;
            },

            /**
             * 生成屏幕外的随机坐标（用于元素飞入）
             */
            生成屏外坐标() {
                let x, y;
                if (Math.random() < 0.5) {
                    // 从左右飞入
                    x = Math.random() < 0.5
                        ? -配置.卡片宽度 - Math.random() * 100
                        : 配置.屏幕宽度 + Math.random() * 100;
                    y = Math.random() * (配置.屏幕高度 - 配置.卡片高度);
                } else {
                    // 从上下飞入
                    x = Math.random() * (配置.屏幕宽度 - 配置.卡片宽度);
                    y = Math.random() < 0.5
                        ? -配置.卡片高度 - Math.random() * 100
                        : 配置.屏幕高度 + Math.random() * 100;
                }
                return {x: Math.round(x), y: Math.round(y)};
            },

            /**
             * 分配旋转角度（0-360度均匀分布）
             */
            分配角度(数量, 跨度范围 = [30, 40]) {
                if (数量 <= 0) return [];
                if (数量 === 1) return [0];
                if (数量 === 2) return [0, 360];

                const 角度列表 = [];
                const 中点 = Math.floor(数量 / 2);
                const 余数 = 数量 % 2;
                const [最小跨度, 最大跨度] = 跨度范围;

                // 第一段：0 -> 中间
                for (let i = 0; i < 中点; i++) {
                    const 上一个 = 角度列表[i - 1] || 0;
                    const 跨度 = 最小跨度 + Math.random() * (最大跨度 - 最小跨度);
                    角度列表.push(上一个 + 跨度);
                }

                // 奇数时的中间元素
                if (余数) {
                    const 上一个 = 角度列表[角度列表.length - 1];
                    const 跨度 = 最小跨度 + Math.random() * (最大跨度 - 最小跨度);
                    角度列表.push(上一个 + 跨度);
                }

                // 第二段：中间 -> 360
                for (let i = 0; i < 中点 - (余数 ? 0 : 1); i++) {
                    const 上一个 = 角度列表[角度列表.length - 1];
                    const 跨度 = 最小跨度 + Math.random() * (最大跨度 - 最小跨度);
                    角度列表.push(上一个 + 跨度);
                }

                // 最后固定360度
                角度列表.push(360);
                return 角度列表;
            },

            /**
             * 点击产生爱心特效
             */
            点击爱心特效(目标元素, 事件) {
                const 基准X = 事件.clientX;
                const 基准Y = 事件.clientY;
                const 数量 = Math.floor(this.随机区间(6, 12));

                for (let i = 0; i < 数量; i++) {
                    const x = 基准X + this.随机区间(-20, 20);
                    const y = 基准Y + this.随机区间(-10, 10);
                    setTimeout(() => this.创建爱心(x, y), i * 60);
                }
            },

            /**
             * 创建单个爱心
             */
            创建爱心(x, y) {
                const 大小 = this.随机区间(10, 25);
                const 上升高度 = -this.随机区间(120, 220);
                const 偏移X = this.随机区间(-80, 80);
                const 持续时间 = this.随机区间(1200, 1800);
                const 颜色对 = this.随机渐变色();
                const 颜色 = 颜色对[Math.floor(Math.random() * 颜色对.length)];

                const $爱心 = $('<span class="爱心"><span class="爱心主体"></span></span>');
                $爱心.css({
                    left: x + 'px',
                    top: y + 'px',
                    width: 大小 + 'px',
                    height: 大小 + 'px',
                    '--上升高度': 上升高度 + 'px',
                    '--偏移X': 偏移X + 'px',
                    animation: `爱心漂浮动画 ${持续时间}ms ease-out forwards`
                });
                $爱心.find('.爱心主体').css({background: 颜色});

                document.body.appendChild($爱心[0]);
                setTimeout(() => $爱心.remove(), 持续时间 + 100);
            },

            /**
             * 元素持续冒爱心
             */
            元素冒爱心(目标元素, 间隔范围 = [500, 3000]) {
                let 活跃状态 = true;

                const 冒爱心循环 = () => {
                    if (!活跃状态) return;

                    const 矩形 = 目标元素.getBoundingClientRect();
                    const 数量 = Math.floor(this.随机区间(1, 6));

                    for (let i = 0; i < 数量; i++) {
                        const x = 矩形.left + 矩形.width / 2 + this.随机区间(-矩形.width / 2, 矩形.width / 2);
                        const y = 矩形.top + 矩形.height / 2 + this.随机区间(-矩形.height / 4, 矩形.height / 4);
                        this.创建爱心(x, y);
                    }

                    setTimeout(冒爱心循环, this.随机区间(间隔范围[0], 间隔范围[1]));
                };

                冒爱心循环();
                return () => {
                    活跃状态 = false;
                };
            }
        };

        // ===========================================
        // 鼓励语句数据库
        // ===========================================
        const 鼓励语句库 = [
            "你今天真棒，继续加油",
            "笑容真好，感染了大家",
            "你的努力值得称赞",
            "坚持下去，奇迹会来",
            "每一天都有新的收获",
            "勇敢追梦，你最棒",
            "你让世界更美好",
            "温暖总会传递下去",
            "做自己喜欢的事最棒",
            "相信自己，你很优秀",
            "阳光从你笑容中洒出",
            "每一步都是成长的足迹",
            "努力的人最闪亮",
            "你的付出值得尊重",
            "今天也要开心满满",
            "梦想会因你而发光",
            "你是别人眼中的光",
            "善良的你最迷人",
            "相信明天会更好",
            "你值得所有美好",
            "你的笑容让人安心",
            "每一天都是新的开始",
            "你散发着正能量",
            "坚持梦想，永不放弃",
            "你拥有无限可能",
            "今天的努力会有回报",
            "你让世界变得温柔",
            "保持微笑，好运会来",
            "你很特别，别忘了",
            "勇敢迈出每一步",
            "努力是最好的礼物",
            "你值得被温柔对待",
            "生活因你而精彩",
            "你的心意很珍贵",
            "努力的人最有魅力",
            "你带来满满的正能量",
            "每一天都是新的希望",
            "你是闪闪发光的人",
            "梦想因你而璀璨",
            "你的坚持令人佩服",
            "温暖总会被感受到",
            "今天也要对自己好",
            "你让人感到安心",
            "笑容是你最美的武器",
            "未来会因你更美好",
            "你做得很棒，不要停",
            "每天都是新的机会",
            "你很优秀，要相信自己",
            "坚持就是胜利",
            "你值得所有美好回报",
            "你让人感到温暖",
            "每一步都是成长",
            "你的努力不会白费",
            "今天也要充满能量",
            "你带来满满希望",
            "你很特别，值得骄傲",
            "坚持自己的信念",
            "未来因你更精彩",
            "你的努力最闪亮",
            "每一天都是礼物",
            "你值得被认可",
            "勇敢去追梦想",
            "你的笑容很温暖",
            "你的人生值得期待",
            "保持努力，你最棒",
            "你让世界更温柔",
            "今天也要开心起来",
            "相信自己，一切都会好",
            "你很优秀，别忘了",
            "你的付出很珍贵",
            "努力的人最闪亮",
            "你值得所有美好",
            "每一天都是新的希望",
            "你是别人眼中的光",
            "你的坚持令人敬佩",
            "温暖总会传递下去",
            "你让生活充满阳光",
            "今天也要微笑满满",
            "勇敢面对每一天",
            "你带来正能量",
            "努力会带来收获",
            "你是特别的人",
            "坚持梦想，奇迹会来",
            "你的人生很精彩",
            "每一天都是机会",
            "你值得所有美好回报",
            "笑容是最好的礼物",
            "你让人感到安心",
            "保持热爱，你最棒",
            "你的人生因你而美",
            "努力的人最迷人",
            "你带来温暖和希望",
            "每一步都是成长的脚印",
            "你值得被珍惜",
            "今天也要充满力量",
            "勇敢去追自己的梦",
            "你让世界更温暖",
            "坚持就是最美的勇气",
            "你很优秀，要相信自己",
            "你的努力不会白费",
            "微笑面对每一天",
            "你的人生充满可能",
            "努力的人最闪亮",
            "你值得所有美好",
            "每一天都是新的开始",
            "你是闪闪发光的人",
            "梦想因你而璀璨",
            "你的坚持令人佩服",
            "温暖总会被感受到",
            "今天也要对自己好",
            "你让人感到安心",
            "笑容是你最美的武器",
            "未来会因你更美好",
            "你做得很棒，不要停",
            "每天都是新的机会",
            "你很优秀，要相信自己",
            "坚持就是胜利",
            "你值得所有美好回报",
            "你让人感到温暖",
            "每一步都是成长",
            "你的努力不会白费",
            "今天也要充满能量",
            "你带来满满希望",
            "你很特别，值得骄傲",
            "坚持自己的信念",
            "未来因你更精彩",
            "你的努力最闪亮",
            "每一天都是礼物",
            "你值得被认可",
            "勇敢去追梦想",
            "你的笑容很温暖",
            "你的人生值得期待",
            "保持努力，你最棒",
            "你让世界更温柔",
            "今天也要开心起来",
            "相信自己，一切都会好",
            "你很优秀，别忘了",
            "你的付出很珍贵",
            "努力的人最闪亮",
            "你值得所有美好",
            "每一天都是新的希望",
            "你是别人眼中的光",
            "你的坚持令人敬佩",
            "温暖总会传递下去",
            "你让生活充满阳光",
            "今天也要微笑满满",
            "勇敢面对每一天",
            "你带来正能量",
            "努力会带来收获",
            "你是特别的人",
            "坚持梦想，奇迹会来",
            "你的人生很精彩",
            "每一天都是机会",
            "你值得所有美好回报",
            "笑容是最好的礼物",
            "你让人感到安心",
            "保持热爱，你最棒",
            "你的人生因你而美",
            "努力的人最迷人",
            "你带来温暖和希望",
            "每一步都是成长的脚印",
            "你值得被珍惜",
            "今天也要充满力量",
            "勇敢去追自己的梦",
            "你让世界更温暖",
            "坚持就是最美的勇气",
            "你很优秀，要相信自己",
            "你的努力不会白费",
            "微笑面对每一天",
            "你的人生充满可能",
            "努力的人最闪亮",
            "你值得所有美好",
            "每一天都是新的开始",
            "你是闪闪发光的人",
            "梦想因你而璀璨",
            "你的坚持令人佩服",
            "温暖总会被感受到",
            "今天也要对自己好",
            "你让人感到安心",
            "笑容是你最美的武器",
            "未来会因你更美好",
            "你做得很棒，不要停",
            "每天都是新的机会",
            "你很优秀，要相信自己",
            "坚持就是胜利",
            "你值得所有美好回报",
            "你让人感到温暖",
            "每一步都是成长",
            "你的努力不会白费",
            "今天也要充满能量",
            "你带来满满希望",
            "你很特别，值得骄傲",
            "坚持自己的信念",
            "未来因你更精彩",
            "你的努力最闪亮",
            "每一天都是礼物",
            "你值得被认可",
            "勇敢去追梦想",
            "你的笑容很温暖",
            "你的人生值得期待",
            "保持努力，你最棒",
            "你让世界更温柔",
            "今天也要开心起来",
            "相信自己，一切都会好",
            "你很优秀，别忘了",
            "你的付出很珍贵",
            "努力的人最闪亮",
            "你值得所有美好",
            "每一天都是新的希望",
            "你是别人眼中的光",
            "你的坚持令人敬佩",
            "温暖总会传递下去",
            "你让生活充满阳光",
            "今天也要微笑满满",
            "勇敢面对每一天",
            "你带来正能量",
            "努力会带来收获",
            "你是特别的人",
            "坚持梦想，奇迹会来",
            "你的人生很精彩",
            "每一天都是机会",
            "你值得所有美好回报",
            "笑容是最好的礼物",
            "你让人感到安心",
            "保持热爱，你最棒",
            "你的人生因你而美",
            "努力的人最迷人",
            "你带来温暖和希望",
            "每一步都是成长的脚印",
            "你值得被珍惜",
            "今天也要充满力量",
            "勇敢去追自己的梦",
            "你让世界更温暖",
            "坚持就是最美的勇气",
            "你很优秀，要相信自己",
            "你的努力不会白费",
            "微笑面对每一天",
            "你的人生充满可能",
            "努力的人最闪亮",
            "你值得所有美好",
            "每一天都是新的开始",
            "你是闪闪发光的人",
            "梦想因你而璀璨",
            "你的坚持令人佩服",
            "温暖总会被感受到",
            "今天也要对自己好",
            "你让人感到安心",
            "笑容是你最美的武器",
            "未来会因你更美好",
            "你做得很棒，不要停",
            "每天都是新的机会",
            "你很优秀，要相信自己",
            "坚持就是胜利",
            "你值得所有美好回报",
            "你让人感到温暖",
            "每一步都是成长",
            "你的努力不会白费",
            "今天也要充满能量",
            "你带来满满希望",
            "你很特别，值得骄傲",
            "坚持自己的信念",
            "未来因你更精彩",
            "你的努力最闪亮",
            "每一天都是礼物",
            "你值得被认可",
            "勇敢去追梦想",
            "你的笑容很温暖",
            "你的人生值得期待",
            "保持努力，你最棒",
            "你让世界更温柔",
            "今天也要开心起来",
            "相信自己，一切都会好",
            "你很优秀，别忘了",
            "你的付出很珍贵",
            "努力的人最闪亮",
            "你值得所有美好"
        ];

        // ===========================================
        // 主程序：初始化动画
        // ===========================================
        const $body = $('body');
        const 爱心坐标列表 = 工具.生成爱心坐标();
        const 角度列表 = 工具.分配角度(爱心坐标列表.length);

        // 创建所有卡片元素
        const 卡片元素列表 = 爱心坐标列表.map((终点坐标, 索引) => {
            const 起点坐标 = 工具.生成屏外坐标();
            const 渐变色 = 工具.随机渐变色();
            const 文本 = 鼓励语句库[Math.floor(Math.random() * 鼓励语句库.length)];

            return $(`<div class="单个卡片"
            data-索引="${索引}"
            data-起点x="${起点坐标.x}"
            data-起点y="${起点坐标.y}"
            data-终点x="${终点坐标[0]}"
            data-终点y="${终点坐标[1]}"
            style="background: linear-gradient(90deg, ${渐变色[0]}, ${渐变色[1]});
                   left: ${起点坐标.x}px;
                   top: ${起点坐标.y}px;">
            ${文本}
        </div>`);
        });

        // ===========================================
        // 动画序列：飞入 -> 摇摆 -> 旋转 -> 最终特效
        // ===========================================
        $.each(卡片元素列表, function (索引, $卡片) {
            const 起点 = [$卡片.data('起点x'), $卡片.data('起点y')];
            const 终点 = [$卡片.data('终点x'), $卡片.data('终点y')];
            const 曲线路径 = 工具.生成贝塞尔曲线(起点, 终点, [3, 10], [2, 8]);

            // 添加到页面
            $body.append($卡片);

            // 随机延迟添加摇摆效果
            setTimeout(() => {
                $卡片.addClass('左右摇摆');
            }, Math.floor(Math.random() * 5000));

            // 飞入动画
            setTimeout(() => {
                const 动画路径 = [
                    ...曲线路径.map(点 => ({left: 点.x + "px", top: 点.y + "px"})),
                    {left: 终点[0] + "px", top: 终点[1] + "px"}
                ];
                $卡片[0].animate(动画路径, {
                    duration: 配置.飞入动画时长,
                    easing: 'ease-in-out',
                    fill: 'forwards'
                });
            }, 索引 * 配置.飞入延迟间隔);

            // 旋转动画（停止摇摆，旋转到指定角度）
            setTimeout(() => {
                $卡片.removeClass('左右摇摆');
                $卡片.data('旋转角度', 角度列表[索引]);
                $卡片.animate({rotate: 角度列表[索引] + 'deg'}, {
                    duration: 配置.旋转动画时长,
                    easing: 'swing'
                });
            }, (索引 * 配置.飞入延迟间隔) + 配置.旋转延迟);
        });

        // ===========================================
        // 最终特效：最后一个卡片放大浮动并持续冒爱心
        // ===========================================
        const 结束时间 = (卡片元素列表.length * 配置.飞入延迟间隔) + 配置.旋转延迟 + 配置.旋转动画时长;

        setTimeout(() => {
            const $最后卡片 = 卡片元素列表[卡片元素列表.length - 1];

            // 添加短暂放大效果
            $最后卡片.addClass('短暂放大');

            // 1秒后切换到持续浮动并开始冒爱心
            setTimeout(() => {
                $最后卡片.removeClass('短暂放大').addClass('持续浮动');
                工具.元素冒爱心($最后卡片[0], 配置.爱心间隔范围);
            }, 1100);
        }, 结束时间);

        // ===========================================
        // 交互：点击任意卡片产生爱心特效
        // ===========================================
        $body.on('click', '.单个卡片', function (事件) {
            工具.点击爱心特效(this, 事件);
        });

        // ===========================================
        // 控制台输出信息
        // ===========================================
        console.log('%c💖 明天会更好 💖', 'font-size: 20px; color: #ff69b4; font-weight: bold;');
        console.log(`✨ 共生成 ${卡片元素列表.length} 个鼓励卡片`);
        console.log(`🎯 动画总时长约 ${Math.round(结束时间 / 1000)} 秒`);
        console.log('👆 点击卡片会有惊喜哦~');
    });
</script>
</html>